﻿#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <string>
using namespace std;
//class B
//{
//public:
//	int _b = 10;
//};
//class A
//{
//public:
//	A(int a = 0) :_a(a) {	}
//	A(const B& b) :_a(b._b) {	}
//	//重载一个隐式转换成int型的函数
//	operator int() 
//	{
//		return _a + 1;
//	}
//	int _a;
//};
//
//int main()
//{
//	int x = 5;
//	double f = 3.14;
//	A a;
//	B b;
//	a = x; //内置类型隐式转换成自定义类型
//	cout << "A: " << a._a << "  " << "x: " << x << endl;
//	a = b; //自定义类型隐式转换成自定义类型
//	cout << "A: " << a._a << "  " << "B: " << b._b << endl;
//	x = a; //自定义类型隐式转换成内置类型
//	cout << "x: " << x << "  " << "A: " << a._a << endl;
//	x = f; //内置类型之间的隐式类型转换，系统内部自动实现
//	cout << "x: " << x << "  " << "f: " << f << endl;
//	return 0;
//}

//int main()
//{
//	int a = 1;
//	double f = 3.14;
//	char c = 'a';
//	const char* str = "aaa";
//
//	//int* p = &f; 错误，不能隐式转换
//	int* p = (int*)&f;
//	//a = &c; 错误，不能隐式转换
//	a = (int)&c;
//	//p = a; 错误，不能隐式转换
//	p = (int*)a;
//
//	//a = (float)str; const char*与float基本没有相似度，无法强制转换
//	return 0;
//}

//int main()
//{
//	double d = 12.34;
//	int a1 = static_cast<int>(d); //将d隐式转换成int型，然后赋值a1
//	cout << a1 << endl;
//	//上面a1的static_cast<int>(d)隐式转换与下面a2对应
//	int a2 = d; 
//	cout << a2 << endl;
//
//	int* p = &a1;
//	//int a3 = static_cast<int>(p); 错误，相当于a3 = p;
//  //int* p1 = static_cast<int*>(a1); 错误，相当于int* p1 = a1;
//	return 0;
//}

//int main()
//{
//	double f = 3.14;
//	int i = 1;
//	int* pi = &i;
//	double* pf = &f;	
//	
//	int a = static_cast<int>(f);
//	float f1 = static_cast<float>(i);
//	int a1 = reinterpret_cast<int>(pi);
//	int a2 = reinterpret_cast<int>(pf);
//	a = (int)f;
//	//下面都是错误的使用
//	//int a = reinterpret_cast<int>(f); //错误，两数据间可以进行隐式转换
//	//float f1 = reinterpret_cast<float>(i); //错误，同理
//	//int a1 = static_cast<int>(pi); //错误，pi不能隐式转换成int型
//	//int a2 = static_cast<int>(pf);  //错误，同理
//	return 0;
//}

//class A
//{
//public:
//	A(int a = 0)
//		:_a(a)
//	{}
//	int _a;
//};
//int main()
//{
//	int x1 = 1;
//	int x2 = 2;
//	A a1 = static_cast<A>(x1);
//	//float a2 = reinterpret_cast<float>(x1);
//
//	//A a2 = reinterpret_cast<A>(x2); //无法将int型强转为A型
//	a1 = (A)x2;
//	return 0;
//}

//int main()
//{
//	//编译器会对const型数据进行优化，由于const型数据不会改变，这里会把a存入寄存器中，输出打印仍在寄存器中进行，
//	//但内存中a已经被改变，监视窗口从内存中取数据
//	//关键字volatile用于解决这块问题，使用后，即便是const型数据，也不会往寄存器中存取了
//	const int a = 2;
//	int* p = const_cast<int*>(&a); //这里本质也是强制类型转换
//	*p = 3;
//	cout << a << endl;
//	cout << *p << endl;
//	return 0;
//
//}
//int main()
//{
//	// 强制类型转换，但是为什么要把去掉const属性单独拿出来
//	// 就是专门提醒，去掉const属性是有一些内存可见优化的的风险，要注意是否加了volatile
//	volatile const int a1 = 2;
//	int* p1 = const_cast<int*>(&a1); //与int* p1 = (int*)&a1类似
//	*p1 = 3;
//	cout << a1 << endl;
//	cout << *p1 << endl;
//
//	//const_cast与reinterpret_cast对比
//	int a2 = 1;
//	//int p2 = const_cast<int>(p1); //错误，const_cast中的类型必须是指针、引用，
//	int p2 = reinterpret_cast<int>(p1); //属于reinterpret_cast的强制类型转换，正确
//	//int* p3 = const_cast<int*>(a2); 错误，const_cast只能去除const常性，不能更改其类型
//	int* p3 = reinterpret_cast<int*>(a2); //正确，与上同理
//	
//	return 0;
//}

class A
{
public:
	virtual void f() {}

	int _a = 0;
};

class B : public A
{
public:
	int _b = 1;
};

int main()
{
	A a;
	B b;
	A* pa = &a;
	B* pb = &b;

	return 0;
}

void fun(A* pa)
{
	// 向下转换：父->子
	// pa指向子类对象，转回子类，是安全的
	// pa指向父类对象，转回子类，是不安全的，存在越界的风险问题

	// 不安全
	//B* pb = (B*)pa;

	//  pa指向子类对象，转回子类，正常转换
	//  pa指向父类对象，转回子类，转换失败
	B* pb = dynamic_cast<B*>(pa);
	if (pb)
	{
		cout << pb << endl;
		cout << pb->_a << endl;
		cout << pb->_b << endl;
	}
	else
	{
		cout << "转换失败" << endl;
	}
}


//int main()
//{
//	A a;
//	B b;
//
//	fun(&a);
//	fun(&b);
//
//	return 0;
//}

//int main()
//{
//	// 赋值兼容，向上转换，子->父
//	B bb;
//	A aa = bb;
//	A* ptr = &bb;
//
//	return 0;
//}

//int main()
//{
//	B b;
//	A* a = reinterpret_cast<A*>(b);
//	return 0;
//}
